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