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