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