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