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