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