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