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