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