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