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