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