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