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