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