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