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