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