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