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