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