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