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