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