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