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