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