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