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