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